/**
 * 给定数组，中间有未知元素，要求陡峭值恰好为1
 * 构造一个可行解
 * 首先检查已知元素的陡峭值，超过1则无解
 * 然后令还可用的陡峭值为left，left必然是0或1
 * 然后对数组中的每一段未知元素进行填充。
 * 令前后已知值分别为pre和nxt，
 * 如果 |pre - nxt| > left, 则无解
 * 否则 直接填充 pre 即可, left -= |pre - nxt|
 * 这种填法最后只有一个问题，即如果left为1，且所有已知元素均相等
 * 则填完之后数组的陡峭值为0，而不是1
 * 此时只能在数组的两端进行修改。因此能改就改，不能改就无解。
 * 标程是先判断数组模式，即数组必须是 .....1.....2......模式
 * 然后再根据情况讨论
 */
#include <bits/stdc++.h>
#include <bits/extc++.h>
using namespace std;

using llt = long long;
using vi = vector<int>;
using vll = vector<llt>;
using pii = pair<int, int>;
using vpii = vector<pii>;

template<typename T>
void input(vector<T>&v, int n){
    v.assign(n + 1, {});
    for(int i=1;i<=n;++i)cin>>v[i];
    return;
}

int N;
vi A;
vi Flag;

bool proc(int s, int len, int pre, int nxt, int & left){
    fill(Flag.begin() + s, Flag.begin() + s + len, 1);

    int level = 0;
    if(-1 == pre and -1 == nxt){
        level = 1;
    }else if(-1 == pre){
        level = nxt;
    }else if(-1 == nxt){
        level = pre;
    }

    if(level){
        fill(A.begin() + s, A.begin() + s + len, level);
        return true;
    }

    auto cha = nxt - pre;
    if(cha < 0) cha = -cha;

    if(cha > left) return false;

    fill(A.begin() + s, A.begin() + s + len, pre);
    left -= cha;
    return true;
}

bool proc(int left){
    Flag.assign(N + 1, 0);
    int pre = -1;
    int k = 1;
    while(1){
        int o = 0;
        while(k + o <= N and A[k+o] == 0){
            ++o;
        }
        if(o){
            int nxt = -1;
            if(k + o <= N) nxt = A[k + o];
            bool flag = proc(k, o, pre, nxt, left);
            if(not flag) return false;
        }

        if((k + o) == N + 1) break;

        while(k <= N and A[k]) {
            pre = A[k];
            ++k;
        }
        if(k == N + 1) break;
    }

    if(left != 0) {
        if(Flag[1] == 1) {
            if(A[1] > 1) {
                A[1] -= 1;
            }else{
                A[1] += 1;
            }
            return true;
        }
        if(Flag[N] == 1){
            if(A[N] > 1) {
                A[N] -= 1;
            }else{
                A[N] += 1;
            }
            return true;
        }
        return false;
    }

    return true;
}

void work(){
    cin >> N;
    input(A, N);

    int tmp = 0;
    for(int i=2;i<=N;++i){
        if(A[i - 1] and A[i]){
            auto cha = A[i] - A[i - 1];
            if(cha < 0) cha = -cha;
            tmp += cha;
        }
    }

    if(tmp > 1) return (void)(cout << "-1\n");

    bool b = proc(tmp ^ 1);
    if(not b) return (void)(cout << "-1\n");

    for(int i=1;i<=N;++i) cout << A[i] << " ";
    cout << endl;
    return;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	int nofkase = 1;
    // cin >> nofkase;
    while(nofkase--) {
		work();
	}
    return 0;
}